package qc.module.platform.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.module.platform.entity.QcRoleUser;
import qc.module.platform.repository.QcRoleUserRepository;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class RoleUserService {

    private QcRoleUserRepository repository;

    @Autowired
    public void setRepository(QcRoleUserRepository repository) {
        this.repository = repository;
    }

    /**
     * 判断关联关系是否存在
     *
     * @param roleId 角色ID
     * @param userId 用户ID
     * @return boolean
     * @author QuCheng Tech
     * @since 2023/9/2
     */
    public boolean hasExist(int roleId, int userId) {
        LambdaQueryWrapper<QcRoleUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(QcRoleUser::getRoleid, roleId);
        wrapper.eq(QcRoleUser::getUserid, userId);

        QcRoleUser en = repository.selectOne(wrapper);
        if (en != null)
            return true;

        return false;
    }

    /**
     * 添加角色用户关联关系
     *
     * @param roleId 角色id
     * @param userId 用户id
     * @return 成功返回null
     */
    public void add(int roleId, int userId) {
        //判断角色用户是否已经关联如果已经关联则不添加
        if (!hasExist(roleId, userId)) {
            QcRoleUser qcRoleUser = new QcRoleUser();
            qcRoleUser.setRoleid(roleId);
            qcRoleUser.setUserid(userId);
            repository.insert(qcRoleUser);
        }
    }

    /**
     * 获取指定角色关联的用户ID集合
     *
     * @param roleId 角色ID
     * @return 角色与用户关联关系
     * @author
     */
    public List<Integer> getUserIds(int roleId) {
        LambdaQueryWrapper<QcRoleUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(QcRoleUser::getUserid);
        wrapper.eq(QcRoleUser::getRoleid, roleId);
        //查询数据
        List<QcRoleUser> ens = repository.selectList(wrapper);
        if (ens != null && ens.size() > 0x0) {
            return ens.stream().map(QcRoleUser::getUserid).collect(Collectors.toList());
        }

        return null;
    }

    /**
     * 获取指定用户ID关联的角色ID，可以传入过滤的角色ID集合
     *
     * @param userId 用户ID
     * @param filterRoleIds 过滤的角色ID集合
     * @return java.util.List<java.lang.Integer>
     * @author QuCheng Tech
     * @since 2023/8/30
     */
    public List<Integer> getRoleIds(int userId, List<Integer> filterRoleIds) {
        if (filterRoleIds != null && filterRoleIds.size() > 0x0) {
            LambdaQueryWrapper<QcRoleUser> wrapper = new LambdaQueryWrapper<>();
            wrapper.select(QcRoleUser::getRoleid);
            wrapper.eq(QcRoleUser::getUserid, userId);
            wrapper.in(QcRoleUser::getRoleid, filterRoleIds);
            //查询数据
            List<QcRoleUser> ens = repository.selectList(wrapper);
            if (ens != null && ens.size() > 0x0) {
                return ens.stream().map(QcRoleUser::getRoleid).collect(Collectors.toList());
            }
        }

        return null;
    }

    /**
     * 根据角色ID删除关联关系
     *
     * @param roleId 角色id
     * @return 成功返回null
     */
    public void deleteByRoleId(int roleId) {
        LambdaUpdateWrapper<QcRoleUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(QcRoleUser::getRoleid, roleId);
        repository.delete(wrapper);
    }

    /**
     * 根据用户ID删除关联关系，谨慎调用，会删除指定用户ID的所有项目中的角色关联关系（在平台中删除用户时使用）
     *
     * @param userId 用户id
     * @return 成功返回null
     */
    public void deleteByUserId(int userId) {
        LambdaUpdateWrapper<QcRoleUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(QcRoleUser::getUserid, userId);
        repository.delete(wrapper);
    }

    /**
     * 根据角色ID批量删除角色与用户的关联关系
     *
     * @param roleIds 角色id
     * @return 成功返回null
     */
    public void deleteByRoleIds(List<Integer> roleIds) {
        LambdaUpdateWrapper<QcRoleUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(QcRoleUser::getRoleid, roleIds);
        repository.delete(wrapper);
    }
}
